home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / CIncludes / OpenTptAppleTalk.h < prev    next >
C/C++ Source or Header  |  1996-05-01  |  20KB  |  736 lines
  1. /*
  2.     File:        OpenTptAppleTalk.h
  3.  
  4.     Contains:    Public AppleTalk definitions
  5.  
  6.     Copyright:    © 1993-1995 by Apple Computer, Inc., all rights reserved.
  7.  
  8.  
  9. */
  10.  
  11. #ifndef __OPENTPTAPPLETALK__
  12. #define __OPENTPTAPPLETALK__
  13.  
  14. #ifndef REZ
  15.     #ifndef __OPENTRANSPORT__
  16.     #include <OpenTransport.h>
  17.     #endif
  18.     #if GENERATINGPOWERPC
  19.     #pragma options align=mac68k
  20.     #endif
  21. #endif
  22.  
  23. /*******************************************************************************
  24. ** Some prefixes for shared libraries
  25. ********************************************************************************/
  26.  
  27. #define kATalkVersion    "1.0"
  28. #define kATalkPrefix    "ot:atlk$"
  29. #define kATBinderID        "ot:atbd$"
  30.  
  31. /*******************************************************************************
  32. ** Module definitions
  33. ********************************************************************************/
  34. //
  35. // XTI Levels
  36. //
  37. #define ATK_DDP            'DDP '
  38. #define ATK_AARP        'AARP'
  39. #define ATK_ATP            'ATP '
  40. #define ATK_ADSP        'ADSP'
  41. #define ATK_ASP            'ASP '
  42. #define ATK_PAP            'PAP '
  43. #define ATK_NBP            'NBP '
  44. #define ATK_ZIP            'ZIP '
  45. //
  46. // Module Names
  47. //
  48. #define kDDPName        "ddp"
  49. #define    kATPName        "atp"
  50. #define kADSPName        "adsp"
  51. #define    kASPName        "asp"
  52. #define kPAPName        "pap"
  53. #define kNBPName        "nbp"
  54. #define kZIPName        "zip"
  55. #define kLTalkName        "ltlk"
  56. #define kLTalkAName        "ltlkA"
  57. #define kLTalkBName        "ltlkB"
  58.  
  59. /*******************************************************************************
  60. ** Protocol-specific Options
  61. **
  62. ** NOTE:
  63. ** All Protocols support OPT_CHECKSUM (Value is (unsigned long)T_YES/T_NO)
  64. ** ATP supports OPT_RETRYCNT (# Retries, 0 = try once) and
  65. **                OPT_INTERVAL (# Milliseconds to wait)
  66. ********************************************************************************/
  67.  
  68. #define DDP_OPT_CHECKSUM    OPT_CHECKSUM,
  69.                                     
  70. #define ATP_OPT_REPLYCNT    0x2110    /* AppleTalk - ATP Resp Pkt Ct Type            */
  71.                                     /* Value is (unsigned long)  pkt count        */
  72. #define ATP_OPT_DATALEN        0x2111    /* AppleTalk - ATP Pkt Data Len Type        */
  73.                                     /* Value is (unsigned long) length            */
  74. #define ATP_OPT_RELTIMER    0x2112    /* AppleTalk - ATP Release Timer Type        */
  75.                                     /* Value is (unsigned long) timer            */
  76.                                     /* (See Inside AppleTalk, second edition    */
  77. #define ATP_OPT_TRANID        0x2113    /* Value is (unsigned long) Boolean            */
  78.                                     /* Used to request Transaction ID            */
  79.                                     /* Returned with Transaction ID on requests */
  80.  
  81. #define PAP_OPT_OPENRETRY    0x2120    /* AppleTalk - PAP OpenConn Retry count        */
  82.                                     /* Value is (unsigned long) T_YES/T_NO        */
  83.  
  84. /*******************************************************************************
  85. ** Protocol-specific events
  86. ********************************************************************************/
  87.  
  88. #ifndef REZ
  89.  
  90. enum
  91. {
  92.     kAppleTalkEvent                    = kPROTOCOLEVENT | 0x10000,
  93.  
  94.     T_GETMYZONECOMPLETE                = kAppleTalkEvent+1,
  95.     T_GETLOCALZONESCOMPLETE            = kAppleTalkEvent+2,
  96.     T_GETZONELISTCOMPLETE            = kAppleTalkEvent+3,
  97.     T_GETATALKINFOCOMPLETE            = kAppleTalkEvent+4,
  98.     
  99.     //
  100.     // If you send the IOCTL: OTIoctl(I_OTGetMiscellaneousEvents, 1),
  101.     // you will receive these events on your endpoint.
  102.     // NOTE: The endpoint does not need to be bound.
  103.     //
  104.     // No routers have been seen for a while.  If the cookie is NULL,
  105.     // all routers are gone.  Otherwise, there is still an ARA router
  106.     // hanging around being used, and only the local cable has been 
  107.     // timed out.
  108.     //
  109.     T_ATALKROUTERDOWNEVENT            = kAppleTalkEvent + 51,
  110.         //
  111.         // This indicates that all routers are offline
  112.         //
  113.         kAllATalkRoutersDown            = 0,
  114.         //
  115.         // This indicates that all local routers went offline, but
  116.         // an ARA router is still active
  117.         //
  118.         kLocalATalkRoutersDown            = -1L,
  119.         //
  120.         // This indicates that ARA was disconnected, do it's router went offline,
  121.         // and we have no local routers to fall back onto.
  122.         //
  123.         kARARouterDisconnected            = -2L,
  124.     //
  125.     // We didn't have a router, but now one has come up.
  126.     // Cookie is NULL for a normal router coming up, non-NULL
  127.     // for an ARA router coming on-line
  128.     //
  129.     T_ATALKROUTERUPEVENT            = kAppleTalkEvent + 52,
  130.         //
  131.         // We had no local routers, but an ARA router is now online.
  132.         //
  133.         kARARouterOnline                = -1L,
  134.         //
  135.         // We had no routers, but a local router is now online
  136.         //
  137.         kATalkRouterOnline                = 0,
  138.         //
  139.         // We have an ARA router, but now we've seen a local router as well
  140.         //
  141.         kLocalATalkRouterOnline             = -2L,
  142.     //
  143.     // A Zone name change was issued from the router, so our
  144.     // AppleTalk Zone has changed.
  145.     //
  146.     T_ATALKZONENAMECHANGEDEVENT        = kAppleTalkEvent + 53,
  147.     //
  148.     // An ARA connection was established (cookie != NULL),
  149.     // or was disconnected (cookie == NULL)
  150.     //
  151.     T_ATALKCONNECTIVITYCHANGEDEVENT    = kAppleTalkEvent + 54,
  152.     //
  153.     // A router has appeared, and our address is in the startup
  154.     // range.  Cookie is hi/lo of new cable range.
  155.     //
  156.     T_ATALKINTERNETAVAILABLEEVENT    = kAppleTalkEvent + 55,
  157.     //
  158.     // A router has appeared, and it's incompatible withour
  159.     // current address.  Cookie is hi/lo of new cable range.
  160.     //
  161.     T_ATALKCABLERANGECHANGEDEVENT    = kAppleTalkEvent + 56
  162.     //
  163.     // A bad router has appeared/disappeared on our network.
  164.     //
  165. };
  166.  
  167. #define IsAppleTalkEvent(x)            ((x) & 0xffff0000) == kAppleTalkEvent)
  168.  
  169. /*******************************************************************************
  170. ** Protocol-specific constants
  171. ********************************************************************************/
  172.  
  173. enum
  174. {
  175.     /*    -------------------------------------------------------------------------
  176.         ECHO
  177.         ------------------------------------------------------------------------- */
  178.  
  179.     kECHO_TSDU                = 585,        // Max. # of data bytes.
  180.  
  181.     /*    -------------------------------------------------------------------------
  182.         NBP
  183.         ------------------------------------------------------------------------- */
  184.  
  185.     kNBPMaxNameLength        = 32,
  186.     kNBPMaxTypeLength        = 32,
  187.     kNBPMaxZoneLength        = 32,
  188.     kNBPSlushLength            = 9,    // Extra space for @, : and a few escape chars
  189.     kNBPMaxEntityLength        = (kNBPMaxNameLength + kNBPMaxTypeLength + kNBPMaxZoneLength + 3),
  190.     kNBPEntityBufferSize    = (kNBPMaxNameLength + kNBPMaxTypeLength + kNBPMaxZoneLength + kNBPSlushLength),
  191.     kNBPWildCard            = 0x3D,        // NBP name and type match anything '='
  192.     kNBPImbeddedWildCard    = 0xC5,        // NBP name and type match some '~='
  193.     kNBPDefaultZone            = 0x2A,        // NBP default zone '*'
  194.  
  195.     /*    -------------------------------------------------------------------------
  196.         ZIP
  197.         ------------------------------------------------------------------------- */
  198.     
  199.     kZIPMaxZoneLength        = kNBPMaxZoneLength,
  200.     
  201.     /*    -------------------------------------------------------------------------
  202.         Address-related values
  203.         ------------------------------------------------------------------------- */
  204.         
  205.     kDDPAddressLength        = 8,        // value to use in netbuf.len field
  206.                                         // Maximum length of AppleTalk address
  207.     kNBPAddressLength        = kNBPEntityBufferSize,
  208.     kAppleTalkAddressLength    = kDDPAddressLength + kNBPEntityBufferSize
  209. };
  210.  
  211. #define OTCopyDDPAddress(addr, dest)                \
  212.     {                                                \
  213.         ((UInt32*)(dest))[0] = ((UInt32*)(addr))[0];    \
  214.         ((UInt32*)(dest))[1] = ((UInt32*)(addr))[1];    \
  215.     }
  216.  
  217. /*******************************************************************************
  218. ** CLASS TAppleTalkServices
  219. ********************************************************************************/
  220.  
  221. #if !OTKERNEL
  222.  
  223. #ifndef __cplusplus
  224.     typedef void*    ATSvcRef;
  225. #else
  226.     class TAppleTalkServices;
  227.     typedef TAppleTalkServices*    ATSvcRef;
  228. #endif
  229.  
  230. #define kDefaultAppleTalkServicesPath    ((OTConfiguration*)-3)
  231.  
  232. #ifdef __cplusplus
  233. extern "C" {
  234. #endif
  235.  
  236. extern pascal OSStatus    OTAsyncOpenAppleTalkServices(OTConfiguration* cfig, OTOpenFlags flags,
  237.                                                      OTNotifyProcPtr, void* contextPtr);            
  238. extern pascal ATSvcRef    OTOpenAppleTalkServices(OTConfiguration* cfig, OTOpenFlags flags,
  239.                                                 OSStatus* err);
  240.     //
  241.     // Get the zone associated with the ATSvcRef
  242.     //
  243. extern pascal OSStatus    OTATalkGetMyZone(ATSvcRef ref, TNetbuf* zone);
  244.     //
  245.     // Get the list of available zones associated with the local cable
  246.     // of the ATSvcRef
  247.     //
  248. extern pascal OSStatus    OTATalkGetLocalZones(ATSvcRef ref, TNetbuf* zones);
  249.     //
  250.     // Get the list of all zones on the internet specified by the ATSvcRef
  251.     //
  252. extern pascal OSStatus    OTATalkGetZoneList(ATSvcRef ref, TNetbuf* zones);
  253.     //
  254.     // Stores an AppleTalkInfo structure into the TNetbuf (see later in this file)
  255.     //
  256. extern pascal OSStatus    OTATalkGetInfo(ATSvcRef ref, TNetbuf* info);
  257.  
  258. #ifdef __cplusplus
  259. }
  260.  
  261. class TAppleTalkServices : public TProvider
  262. {
  263.     public:
  264.             OSStatus    GetMyZone(TNetbuf* zone)         { return OTATalkGetMyZone(this, zone); }
  265.             OSStatus    GetLocalZones(TNetbuf* zones)    { return OTATalkGetLocalZones(this, zones); }
  266.             OSStatus    GetZoneList(TNetbuf* zones)        { return OTATalkGetZoneList(this, zones); }
  267.             OSStatus    GetInfo(TNetbuf* info)            { return OTATalkGetInfo(this, info); }
  268. };
  269.  
  270. #endif    /* _cplus */
  271. #endif    /* !OTKERNEL */
  272.  
  273. /*    -------------------------------------------------------------------------
  274.     AppleTalk Addressing
  275.     
  276.     The NBPEntity structure is used to manipulate NBP names without regard
  277.     to issues of what kind of "special" characters are in the name.
  278.     
  279.     When stored as an address in an NBPAddress or DDPNBPAddress, they are 
  280.     stored as a character string, which is currently just ASCII, but in the
  281.     future may be UniChar, or some other internationalizable scripting set.
  282.     The string following an NBPAddress or DDPNBPAddress is intended to be
  283.     suitable for showing to users, whereas NBPEntity is not.
  284.     WARNING: NBPAddress and DDPNBPAddress structures do not "know" the length
  285.     of the address.  That must have been obtained as part of a Lookup or
  286.     ResolveAddress call.
  287.     ------------------------------------------------------------------------- */
  288.  
  289.     typedef struct DDPAddress        DDPAddress;
  290.     typedef struct NBPAddress        NBPAddress;
  291.     typedef struct DDPNBPAddress    DDPNBPAddress;
  292.     
  293.     struct NBPEntity
  294.     {
  295.         UInt8    fEntity[kNBPMaxEntityLength];
  296.     };
  297.     
  298.     typedef struct NBPEntity    NBPEntity;
  299.  
  300.     /*    ---------------------------------------------------------------------
  301.         These are some utility routines for dealing with NBP and DDP addresses. 
  302.         --------------------------------------------------------------------- */
  303.     
  304.     #ifdef __cplusplus
  305.     extern "C" {
  306.     #endif
  307.     //
  308.     // Functions to initialize the various AppleTalk Address types
  309.     //
  310.     extern pascal void        OTInitDDPAddress(DDPAddress* addr, UInt16 net, UInt8 node,
  311.                                              UInt8 socket, UInt8 ddpType);
  312.     extern pascal size_t    OTInitNBPAddress(NBPAddress* addr, const char* name);
  313.     extern pascal size_t    OTInitDDPNBPAddress(DDPNBPAddress* addr, const char* name,
  314.                                                 UInt16 net, UInt8 node, UInt8 socket,
  315.                                                 UInt8 ddpType);
  316.         //
  317.         // Compare 2 DDP addresses for equality
  318.         //
  319.     extern pascal Boolean    OTCompareDDPAddresses(const DDPAddress* addr1, const DDPAddress* addr2);
  320.         //
  321.         // Init an NBPEntity to a NULL name
  322.         //
  323.     extern pascal void        OTInitNBPEntity(NBPEntity* entity);
  324.         //
  325.         // Get the length an NBPEntity would have when stored as an address
  326.         // 
  327.     extern pascal size_t    OTGetNBPEntityLengthAsAddress(const NBPEntity* entity);
  328.         //
  329.         // Store an NBPEntity into an address buffer
  330.         //
  331.     extern pascal size_t    OTSetAddressFromNBPEntity(UInt8* nameBuf, const NBPEntity* entity);
  332.         //
  333.         // Create an address buffer from a string (use -1 for len to use strlen)
  334.         //
  335.     extern pascal size_t    OTSetAddressFromNBPString(UInt8* addrBuf, const char* name, SInt32 len);
  336.         //
  337.         // Create an NBPEntity from an address buffer. False is returned if
  338.         //   the address was truncated.
  339.         //
  340.     extern pascal Boolean    OTSetNBPEntityFromAddress(NBPEntity* entity, const UInt8* addrBuf,
  341.                                                       size_t len);
  342.         //
  343.         // Routines to set a piece of an NBP entity from a character string
  344.         //
  345.     extern pascal Boolean    OTSetNBPName(NBPEntity* entity, const char* name);
  346.     extern pascal Boolean    OTSetNBPType(NBPEntity* entity, const char* typeVal);
  347.     extern pascal Boolean    OTSetNBPZone(NBPEntity* entity, const char* zone);
  348.         //
  349.         // Routines to extract pieces of an NBP entity
  350.         //
  351.     extern pascal void        OTExtractNBPName(const NBPEntity* entity, char* name);
  352.     extern pascal void        OTExtractNBPType(const NBPEntity* entity, char* typeVal);
  353.     extern pascal void        OTExtractNBPZone(const NBPEntity* entity, char* zone);
  354.                                                 
  355.     #ifdef __cplusplus
  356.     }
  357.     #endif
  358.  
  359.     enum
  360.     {
  361.         AF_ATALK_FAMILY    = 0x0100,
  362.         AF_ATALK_DDP    = AF_ATALK_FAMILY,
  363.         AF_ATALK_DDPNBP    = AF_ATALK_FAMILY + 1,
  364.         AF_ATALK_NBP    = AF_ATALK_FAMILY + 2,
  365.         AF_ATALK_MNODE    = AF_ATALK_FAMILY + 3
  366.     };
  367.  
  368. struct DDPAddress
  369. {
  370.     OTAddressType    fAddressType;        // One of the enums above
  371.     UInt16            fNetwork;
  372.     UInt8            fNodeID;
  373.     UInt8            fSocket;
  374.     UInt8            fDDPType;
  375.     UInt8            fPad;
  376. #ifndef __cplusplus
  377.  
  378. };
  379.  
  380. #else
  381.  
  382.     public:
  383.                 void            Init(const DDPAddress&);
  384.                 void            Init(UInt16 net, UInt8 node, UInt8 socket);
  385.                 void            Init(UInt16 net, UInt8 node, UInt8 socket, UInt8 type);
  386.  
  387.                 void            SetSocket(UInt8);
  388.                 void            SetType(UInt8);
  389.                 void            SetNode(UInt8);
  390.                 void            SetNetwork(UInt16);
  391.             
  392.                 size_t            GetAddressLength() const;
  393.                 OTAddressType    GetAddressType() const;
  394.                 UInt8            GetSocket() const;
  395.                 UInt8            GetType() const;
  396.                 UInt8            GetNode() const;
  397.                 UInt16            GetNetwork() const;
  398.             
  399.                 Boolean            operator==(const DDPAddress&) const;
  400.                 Boolean            operator!=(const DDPAddress&) const;
  401.                 void            operator=(const DDPAddress&);
  402. };
  403.  
  404. /*
  405.  *    Inline methods for DDPAddress
  406.  */
  407.  
  408.     inline void DDPAddress::operator=(const DDPAddress& addr)
  409.     {
  410.         *(UInt32*)&fAddressType = *(UInt32*)&addr.fAddressType;
  411.         *(UInt32*)&fNodeID = *(UInt32*)&addr.fNodeID;
  412.     }
  413.     
  414.     inline Boolean DDPAddress::operator==(const DDPAddress& addr) const
  415.     {
  416.         return OTCompareDDPAddresses(&addr, this);
  417.     }
  418.     
  419.     inline Boolean DDPAddress::operator!=(const DDPAddress& addr) const
  420.     {
  421.         return !OTCompareDDPAddresses(&addr, this);
  422.     }
  423.     
  424.     inline void DDPAddress::SetSocket(UInt8 socket)
  425.     {
  426.         fSocket = socket;
  427.     }
  428.     
  429.     inline void DDPAddress::SetNode(UInt8 node)
  430.     {
  431.         fNodeID = node;
  432.     }
  433.     
  434.     inline void DDPAddress::SetType(UInt8 type)
  435.     {
  436.         fDDPType = type;
  437.     }
  438.     
  439.     inline void DDPAddress::SetNetwork(UInt16 net)
  440.     {
  441.         fNetwork = net;
  442.     }
  443.     
  444.     inline size_t DDPAddress::GetAddressLength() const
  445.     {
  446.         return kDDPAddressLength;
  447.     }
  448.     
  449.     inline OTAddressType DDPAddress::GetAddressType() const
  450.     {
  451.         return fAddressType;
  452.     }
  453.     
  454.     inline UInt8 DDPAddress::GetSocket() const
  455.     {
  456.         return fSocket;
  457.     }
  458.     
  459.     inline UInt8 DDPAddress::GetNode() const
  460.     {
  461.         return fNodeID;
  462.     }
  463.     
  464.     inline UInt8 DDPAddress::GetType() const
  465.     {
  466.         return fDDPType;
  467.     }
  468.     
  469.     inline UInt16 DDPAddress::GetNetwork() const
  470.     {
  471.         return fNetwork;
  472.     }
  473.     
  474.     inline void  DDPAddress::Init(UInt16 net, UInt8 node,
  475.                                   UInt8 socket)
  476.     {
  477.         fAddressType = AF_ATALK_DDP;
  478.         SetNetwork(net);
  479.         SetNode(node);
  480.         SetSocket(socket);
  481.         SetType(0);
  482.     }
  483.     
  484.     inline void  DDPAddress::Init(UInt16 net, UInt8 node,
  485.                                   UInt8 socket, UInt8 type)
  486.     {
  487.         fAddressType = AF_ATALK_DDP;
  488.         SetNetwork(net);
  489.         SetNode(node);
  490.         SetSocket(socket);
  491.         SetType(type);
  492.     }
  493.     
  494.     inline void DDPAddress::Init(const DDPAddress& addr)
  495.     {
  496.         *(UInt32*)&fAddressType = *(UInt32*)&addr.fAddressType;
  497.         *(UInt32*)&fNodeID = *(UInt32*)&addr.fNodeID;
  498.     }
  499.     
  500. #endif    /* __cplusplus */
  501.  
  502.  
  503. struct NBPAddress
  504. {
  505.     OTAddressType    fAddressType;        // One of the enums above
  506.     UInt8            fNBPNameBuffer[kNBPEntityBufferSize];
  507. #ifndef __cplusplus
  508.  
  509. };
  510.  
  511. #else
  512.  
  513.     public:
  514.                 size_t            Init();
  515.                 size_t            Init(const NBPEntity&);
  516.                 size_t            Init(const char*);
  517.                 size_t            Init(const char*, size_t len);
  518.                 Boolean            ExtractEntity(NBPEntity&, size_t len);
  519.             
  520.                 OTAddressType    GetAddressType() const;
  521. };
  522.  
  523. /*
  524.  *    Inline methods for NBPAddress
  525.  */
  526.  
  527.     inline size_t NBPAddress::Init()
  528.     {
  529.         fAddressType = AF_ATALK_NBP;
  530.         return sizeof(OTAddressType);
  531.     }
  532.     
  533.     inline size_t NBPAddress::Init(const NBPEntity& addr)
  534.     {
  535.         fAddressType = AF_ATALK_NBP;
  536.         return sizeof(OTAddressType) + OTSetAddressFromNBPEntity(fNBPNameBuffer, &addr);
  537.     }
  538.     
  539.     inline size_t NBPAddress::Init(const char* name)
  540.     {
  541.         fAddressType = AF_ATALK_NBP;
  542.         return sizeof(OTAddressType) + OTSetAddressFromNBPString(fNBPNameBuffer, name, -1);
  543.     }
  544.     
  545.     inline size_t NBPAddress::Init(const char* name, size_t len)
  546.     {
  547.         fAddressType = AF_ATALK_NBP;
  548.         return sizeof(OTAddressType) + OTSetAddressFromNBPString(fNBPNameBuffer, name, (SInt32)len);
  549.     }
  550.     
  551.     inline Boolean NBPAddress::ExtractEntity(NBPEntity& entity, size_t len)
  552.     {
  553.         return OTSetNBPEntityFromAddress(&entity, fNBPNameBuffer, len);
  554.     }
  555.         
  556.     inline OTAddressType NBPAddress::GetAddressType() const
  557.     {
  558.         return fAddressType;
  559.     }
  560.     
  561. #endif    /* __cplusplus */
  562.  
  563. struct DDPNBPAddress
  564. {
  565.     OTAddressType    fAddressType;        // One of the enums above
  566.     UInt16            fNetwork;
  567.     UInt8            fNodeID;
  568.     UInt8            fSocket;
  569.     UInt8            fDDPType;
  570.     UInt8            fPad;
  571.     UInt8            fNBPNameBuffer[kNBPEntityBufferSize];
  572.  
  573. #ifndef __cplusplus
  574.  
  575. };
  576.  
  577. #else
  578.  
  579.     public:
  580.                 void            Init(const DDPAddress&);
  581.                 void            Init(UInt16 net, UInt8 node, UInt8 socket);
  582.                 void            Init(UInt16 net, UInt8 node, UInt8 socket, UInt8 type);
  583.  
  584.                 void            SetSocket(UInt8);
  585.                 void            SetType(UInt8);
  586.                 void            SetNode(UInt8);
  587.                 void            SetNetwork(UInt16);
  588.                 
  589.                 OTAddressType    GetAddressType() const;
  590.                 UInt8            GetSocket() const;
  591.                 UInt8            GetType() const;
  592.                 UInt8            GetNode() const;
  593.                 UInt16            GetNetwork() const;
  594.                 
  595.                 Boolean            ExtractEntity(NBPEntity&, size_t len);
  596.                 size_t            SetNBPEntity(const NBPEntity&);
  597.                 size_t            SetNBPEntity(const char*);
  598.                 size_t            SetNBPEntity(const char*, size_t len);
  599.                 
  600.                 Boolean            operator==(const DDPAddress&) const;
  601. };
  602.  
  603. /*
  604.  *    Inline methods for DDPNBPAddress
  605.  */
  606.     inline Boolean DDPNBPAddress::operator==(const DDPAddress& addr) const
  607.     {
  608.         return OTCompareDDPAddresses((const DDPAddress*)this, &addr);
  609.     }
  610.     
  611.     inline void DDPNBPAddress::SetSocket(UInt8 socket)
  612.     {
  613.         fSocket = socket;
  614.     }
  615.     
  616.     inline void DDPNBPAddress::SetNode(UInt8 node)
  617.     {
  618.         fNodeID = node;
  619.     }
  620.     
  621.     inline void DDPNBPAddress::SetType(UInt8 type)
  622.     {
  623.         fDDPType = type;
  624.     }
  625.     
  626.     inline void DDPNBPAddress::SetNetwork(UInt16 net)
  627.     {
  628.         fNetwork = net;
  629.     }
  630.     
  631.     inline OTAddressType DDPNBPAddress::GetAddressType() const
  632.     {
  633.         return fAddressType;
  634.     }
  635.     
  636.     inline UInt8 DDPNBPAddress::GetSocket() const
  637.     {
  638.         return fSocket;
  639.     }
  640.     
  641.     inline UInt8 DDPNBPAddress::GetNode() const
  642.     {
  643.         return fNodeID;
  644.     }
  645.     
  646.     inline UInt8 DDPNBPAddress::GetType() const
  647.     {
  648.         return fDDPType;
  649.     }
  650.     
  651.     inline UInt16 DDPNBPAddress::GetNetwork() const
  652.     {
  653.         return fNetwork;
  654.     }
  655.     
  656.     inline void DDPNBPAddress::Init(UInt16 net, UInt8 node,
  657.                                     UInt8 socket)
  658.     {
  659.         fAddressType = AF_ATALK_DDPNBP;
  660.         SetNetwork(net);
  661.         SetNode(node);
  662.         SetSocket(socket);
  663.         SetType(0);
  664.     }
  665.     
  666.     inline void DDPNBPAddress::Init(UInt16 net, UInt8 node,
  667.                                     UInt8 socket, UInt8 type)
  668.     {
  669.         fAddressType = AF_ATALK_DDPNBP;
  670.         SetNetwork(net);
  671.         SetNode(node);
  672.         SetSocket(socket);
  673.         SetType(type);
  674.     }
  675.     
  676.     inline void DDPNBPAddress::Init(const DDPAddress& addr)
  677.     {
  678.         fAddressType = AF_ATALK_DDPNBP;
  679.         SetNetwork(addr.GetNetwork());
  680.         SetNode(addr.GetNode());
  681.         SetSocket(addr.GetSocket());
  682.         SetType(addr.GetType());
  683.         fNBPNameBuffer[0] = 0;
  684.     }
  685.     
  686.     inline size_t DDPNBPAddress::SetNBPEntity(const NBPEntity& entity)
  687.     {
  688.         return OTSetAddressFromNBPEntity(fNBPNameBuffer, &entity) + kDDPAddressLength;
  689.     }
  690.     
  691.     inline size_t DDPNBPAddress::SetNBPEntity(const char* name)
  692.     {
  693.         return OTSetAddressFromNBPString(fNBPNameBuffer, name, -1) + kDDPAddressLength;
  694.     }
  695.     
  696.     inline size_t DDPNBPAddress::SetNBPEntity(const char* name, size_t len)
  697.     {
  698.         return OTSetAddressFromNBPString(fNBPNameBuffer, name, (SInt32)len) + kDDPAddressLength;
  699.     }
  700.     
  701.     inline Boolean DDPNBPAddress::ExtractEntity(NBPEntity& entity, size_t len)
  702.     {
  703.         return OTSetNBPEntityFromAddress(&entity, fNBPNameBuffer, len);
  704.     }
  705.  
  706. #endif    /* __cplusplus */
  707.  
  708. /*    -------------------------------------------------------------------------
  709.         AppleTalkInfo - filled out by the OTGetATalkInfo function
  710.     ------------------------------------------------------------------------- */
  711.  
  712. struct AppleTalkInfo
  713. {
  714.     DDPAddress    fOurAddress;        // Our DDP address (network # & node)
  715.     DDPAddress    fRouterAddress;        // The address of a router on our cable
  716.     UInt16        fCableRange[2];        // The current cable range
  717.     UInt16        fFlags;                // See below
  718. };
  719.  
  720. //
  721. // For the fFlags field in AppleTalkInfo
  722. //
  723. enum
  724. {
  725.     kATalkInfoIsExtended    = 0x0001,    // This is an extended (phase 2) network
  726.     kATalkInfoHasRouter        = 0x0002,    // This cable has a router
  727.     kATalkInfoOneZone        = 0x0004    // This cable has only one zone
  728. };
  729.  
  730. #if GENERATINGPOWERPC
  731. #pragma options align=reset
  732. #endif
  733.  
  734. #endif    /*    REZ    */
  735. #endif    /*  __OPENTPTAPPLETALK__ */
  736.